#include "ParticleAttractor.hpp"
#include <cmath>



/** @brief update
  *
  * @todo: document this function
  */
void ParticleAttractor::update() {
    for (vector<Particle*>::iterator it = system->particles.begin(); it != system->particles.end(); it++) {
        // geen trig, maar vectoren
        const float dx = x - (*it)->x;
        const float dy = y - (*it)->y;
        const float dist = dx*dx+dy*dy;

        // punten ver weg -> skitta
        // Dit is 3D zwaartekracht!!!
        if ( dist <= 100*100 ) {
            switch (mode) {
                case 0: {
                    // puntmassa
                    const float norm = sqrtf(dist);
                    const float normforce = force/(norm*norm*norm);

                    (*it)->x_acceleration += normforce*dx;
                    (*it)->y_acceleration += normforce*dy;
                    break;
                }
                case 1: {
                    // massieve planeet
                    const float norm = sqrtf(dist);
                    float normforce;
                    if ( dist >= radius*radius ) {
                        normforce = force/(norm*norm*norm);
                    } else {
                        normforce = force*norm;
                    }

                    (*it)->x_acceleration += normforce*dx;
                    (*it)->y_acceleration += normforce*dy;
                    break;
                }
                case 2: {
                    // holle planeet, schil heeft een enorme dichtheid
                    // alleen wat doen als het punt buiten de planeet is
                    if ( dist >= radius*radius ) {
                        const float norm = sqrtf(dist);
                        const float normforce = force/(norm*norm*norm);

                        (*it)->x_acceleration += normforce*dx;
                        (*it)->y_acceleration += normforce*dy;
                    }
                    break;
                }
            }
        }
    }
}


/** @brief ParticleAttractor
  *
  * @todo: document this function
  */
ParticleAttractor::ParticleAttractor(ParticleSystem *system, float x, float y, float radius, unsigned int mode):
        system(system), x(x), y(y), radius(radius), force(radius*radius), mode(mode) {

}
ParticleAttractor::ParticleAttractor(ParticleSystem *system, float x, float y, float force):
        system(system), x(x), y(y), radius(0), force(force), mode(0) {

}



/*

    De Zwaartdekracht:
        F = G * (m_1 * m_2)/r^2
        a = F/m
     => a = G * m_2 / r^2

        G * m_2 hebben we force genoemd, we hoeven geen natuurkundig correct model met eenheden
     => a = force / r^2

    De afstand en de hoek:
        hier komen de vectoren
        A is de attractor en B is de particle

        v = A - B               Dit is de verschilvector = (dx, dy)
        r = sqrt(dx^2 + dy^2)   Dit is de lengte van deze vector = ||v||

        om trig te vermijden moeten we de kracht vermenigvuldigen met de genormaliseerde vector
        we moeten de vector delen door zijn lengte, dus

        u = v / ||v|| = (A - B) / r

    Samenstelling:
        a   = force / r^2
        a.x = force / r^2 * u.x
            = force / r^2 * (A.x - B.x) / r
            = force * dx / r^3

*/
